/**
  *******************************************************************************************************
  * @file    fm33le0xxa_fl_rtc.h
  * @author  FMSH Application Team
  * @brief   Head file of RTC FL Module
  *******************************************************************************************************
  * @attention
  * Copyright (c) 2022, SHANGHAI FUDAN MICROELECTRONICS GROUP CO., LTD.(FUDAN MICROELECTRONICS./ FUDAN MICRO.)    
  * All rights reserved.    
  *    
  * Processor:                   FM33LE0xxA    
  * http:                        http://www.fmdevelopers.com.cn/    
  *    
  * Redistribution and use in source and binary forms, with or without    
  * modification, are permitted provided that the following conditions are met    
  *    
  * 1. Redistributions of source code must retain the above copyright notice,    
  *    this list of conditions and the following disclaimer.    
  *    
  * 2. Redistributions in binary form must reproduce the above copyright notice,    
  *    this list of conditions and the following disclaimer in the documentation    
  *    and/or other materials provided with the distribution.    
  *    
  * 3. Neither the name of the copyright holder nor the names of its contributors    
  *    may be used to endorse or promote products derived from this software    
  *    without specific prior written permission.    
  *    
  * 4. To provide the most up-to-date information, the revision of our documents     
  *    on the World Wide Web will be the most Current. Your printed copy may be      
  *    an earlier revision. To verify you have the latest information avaliable,    
  *    refer to: http://www.fmdevelopers.com.cn/.    
  *    
  * THIS SOFTWARE IS PROVIDED BY FUDAN MICRO "AS IS" AND ANY EXPRESSED     
    ORIMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES     
    OF MERCHANTABILITY NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE    
    ARE DISCLAIMED.IN NO EVENT SHALL FUDAN MICRO OR ITS CONTRIBUTORS BE LIABLE     
    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL     
    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS     
    OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER    
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,     
    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISINGIN ANY WAY OUT OF THE     
    USE OF THIS SOFTWARE, EVEN IF ADVISED OFTHE POSSIBILITY OF SUCH DAMAGE.    
  *******************************************************************************************************
  */


/* Define to prevent recursive inclusion---------------------------------------------------------------*/
#ifndef __FM33LE0XXA_FL_RTC_H
#define __FM33LE0XXA_FL_RTC_H

#ifdef __cplusplus
extern "C" {
#endif
/* Includes -------------------------------------------------------------------------------------------*/
#include "fm33le0xxa_fl_def.h"
/** @addtogroup FM33LE0XXA_FL_Driver
  * @{
  */

/** @defgroup RTC RTC
  * @brief RTC FL driver
  * @{
  */

/* Exported types -------------------------------------------------------------------------------------*/
/** @defgroup RTC_FL_ES_INIT RTC Exported Init structures
  * @{
  */

/**
  * @brief Configuration with temporary structure variable users will not be used directly
  */
typedef volatile struct
{
    __IO uint32_t backup[7];
} FL_RTC_Backup_ADDR;

/**
  * @brief RTC Init Sturcture definition
  */
typedef struct
{
    /** 年 */
    uint32_t year;
    /** 月 */
    uint32_t month;
    /** 日 */
    uint32_t day;
    /** 周 */
    uint32_t week;
    /** 时 */
    uint32_t hour;
    /** 分 */
    uint32_t minute;
    /** 秒 */
    uint32_t second;

} FL_RTC_InitTypeDef;

/**
  * @}
  */
/* Exported constants ---------------------------------------------------------------------------------*/
/** @defgroup RTC_FL_Exported_Constants RTC Exported Constants
  * @{
  */

#define    RTC_IER_ADJ_IE_Pos                                     (12U)
#define    RTC_IER_ADJ_IE_Msk                                     (0x1U << RTC_IER_ADJ_IE_Pos)
#define    RTC_IER_ADJ_IE                                         RTC_IER_ADJ_IE_Msk

#define    RTC_IER_ALARM_IE_Pos                                   (11U)
#define    RTC_IER_ALARM_IE_Msk                                   (0x1U << RTC_IER_ALARM_IE_Pos)
#define    RTC_IER_ALARM_IE                                       RTC_IER_ALARM_IE_Msk

#define    RTC_IER_1KHZ_IE_Pos                                    (10U)
#define    RTC_IER_1KHZ_IE_Msk                                    (0x1U << RTC_IER_1KHZ_IE_Pos)
#define    RTC_IER_1KHZ_IE                                        RTC_IER_1KHZ_IE_Msk

#define    RTC_IER_256HZ_IE_Pos                                   (9U)
#define    RTC_IER_256HZ_IE_Msk                                   (0x1U << RTC_IER_256HZ_IE_Pos)
#define    RTC_IER_256HZ_IE                                       RTC_IER_256HZ_IE_Msk

#define    RTC_IER_64HZ_IE_Pos                                    (8U)
#define    RTC_IER_64HZ_IE_Msk                                    (0x1U << RTC_IER_64HZ_IE_Pos)
#define    RTC_IER_64HZ_IE                                        RTC_IER_64HZ_IE_Msk

#define    RTC_IER_16HZ_IE_Pos                                    (7U)
#define    RTC_IER_16HZ_IE_Msk                                    (0x1U << RTC_IER_16HZ_IE_Pos)
#define    RTC_IER_16HZ_IE                                        RTC_IER_16HZ_IE_Msk

#define    RTC_IER_8HZ_IE_Pos                                     (6U)
#define    RTC_IER_8HZ_IE_Msk                                     (0x1U << RTC_IER_8HZ_IE_Pos)
#define    RTC_IER_8HZ_IE                                         RTC_IER_8HZ_IE_Msk

#define    RTC_IER_4HZ_IE_Pos                                     (5U)
#define    RTC_IER_4HZ_IE_Msk                                     (0x1U << RTC_IER_4HZ_IE_Pos)
#define    RTC_IER_4HZ_IE                                         RTC_IER_4HZ_IE_Msk

#define    RTC_IER_2HZ_IE_Pos                                     (4U)
#define    RTC_IER_2HZ_IE_Msk                                     (0x1U << RTC_IER_2HZ_IE_Pos)
#define    RTC_IER_2HZ_IE                                         RTC_IER_2HZ_IE_Msk

#define    RTC_IER_SEC_IE_Pos                                     (3U)
#define    RTC_IER_SEC_IE_Msk                                     (0x1U << RTC_IER_SEC_IE_Pos)
#define    RTC_IER_SEC_IE                                         RTC_IER_SEC_IE_Msk

#define    RTC_IER_MIN_IE_Pos                                     (2U)
#define    RTC_IER_MIN_IE_Msk                                     (0x1U << RTC_IER_MIN_IE_Pos)
#define    RTC_IER_MIN_IE                                         RTC_IER_MIN_IE_Msk

#define    RTC_IER_HOUR_IE_Pos                                    (1U)
#define    RTC_IER_HOUR_IE_Msk                                    (0x1U << RTC_IER_HOUR_IE_Pos)
#define    RTC_IER_HOUR_IE                                        RTC_IER_HOUR_IE_Msk

#define    RTC_IER_DAY_IE_Pos                                     (0U)
#define    RTC_IER_DAY_IE_Msk                                     (0x1U << RTC_IER_DAY_IE_Pos)
#define    RTC_IER_DAY_IE                                         RTC_IER_DAY_IE_Msk

#define    RTC_ISR_ADJ_IF_Pos                                     (12U)
#define    RTC_ISR_ADJ_IF_Msk                                     (0x1U << RTC_ISR_ADJ_IF_Pos)
#define    RTC_ISR_ADJ_IF                                         RTC_ISR_ADJ_IF_Msk

#define    RTC_ISR_ALARM_IF_Pos                                   (11U)
#define    RTC_ISR_ALARM_IF_Msk                                   (0x1U << RTC_ISR_ALARM_IF_Pos)
#define    RTC_ISR_ALARM_IF                                       RTC_ISR_ALARM_IF_Msk

#define    RTC_ISR_1KHZ_IF_Pos                                    (10U)
#define    RTC_ISR_1KHZ_IF_Msk                                    (0x1U << RTC_ISR_1KHZ_IF_Pos)
#define    RTC_ISR_1KHZ_IF                                        RTC_ISR_1KHZ_IF_Msk

#define    RTC_ISR_256HZ_IF_Pos                                   (9U)
#define    RTC_ISR_256HZ_IF_Msk                                   (0x1U << RTC_ISR_256HZ_IF_Pos)
#define    RTC_ISR_256HZ_IF                                       RTC_ISR_256HZ_IF_Msk

#define    RTC_ISR_64HZ_IF_Pos                                    (8U)
#define    RTC_ISR_64HZ_IF_Msk                                    (0x1U << RTC_ISR_64HZ_IF_Pos)
#define    RTC_ISR_64HZ_IF                                        RTC_ISR_64HZ_IF_Msk

#define    RTC_ISR_16HZ_IF_Pos                                    (7U)
#define    RTC_ISR_16HZ_IF_Msk                                    (0x1U << RTC_ISR_16HZ_IF_Pos)
#define    RTC_ISR_16HZ_IF                                        RTC_ISR_16HZ_IF_Msk

#define    RTC_ISR_8HZ_IF_Pos                                     (6U)
#define    RTC_ISR_8HZ_IF_Msk                                     (0x1U << RTC_ISR_8HZ_IF_Pos)
#define    RTC_ISR_8HZ_IF                                         RTC_ISR_8HZ_IF_Msk

#define    RTC_ISR_4HZ_IF_Pos                                     (5U)
#define    RTC_ISR_4HZ_IF_Msk                                     (0x1U << RTC_ISR_4HZ_IF_Pos)
#define    RTC_ISR_4HZ_IF                                         RTC_ISR_4HZ_IF_Msk

#define    RTC_ISR_2HZ_IF_Pos                                     (4U)
#define    RTC_ISR_2HZ_IF_Msk                                     (0x1U << RTC_ISR_2HZ_IF_Pos)
#define    RTC_ISR_2HZ_IF                                         RTC_ISR_2HZ_IF_Msk

#define    RTC_ISR_SEC_IF_Pos                                     (3U)
#define    RTC_ISR_SEC_IF_Msk                                     (0x1U << RTC_ISR_SEC_IF_Pos)
#define    RTC_ISR_SEC_IF                                         RTC_ISR_SEC_IF_Msk

#define    RTC_ISR_MIN_IF_Pos                                     (2U)
#define    RTC_ISR_MIN_IF_Msk                                     (0x1U << RTC_ISR_MIN_IF_Pos)
#define    RTC_ISR_MIN_IF                                         RTC_ISR_MIN_IF_Msk

#define    RTC_ISR_HOUR_IF_Pos                                    (1U)
#define    RTC_ISR_HOUR_IF_Msk                                    (0x1U << RTC_ISR_HOUR_IF_Pos)
#define    RTC_ISR_HOUR_IF                                        RTC_ISR_HOUR_IF_Msk

#define    RTC_ISR_DAY_IF_Pos                                     (0U)
#define    RTC_ISR_DAY_IF_Msk                                     (0x1U << RTC_ISR_DAY_IF_Pos)
#define    RTC_ISR_DAY_IF                                         RTC_ISR_DAY_IF_Msk

#define    RTC_TMSEL_TMSEL_Pos                                    (0U)
#define    RTC_TMSEL_TMSEL_Msk                                    (0xfU << RTC_TMSEL_TMSEL_Pos)
#define    RTC_TMSEL_TMSEL                                        RTC_TMSEL_TMSEL_Msk

#define    RTC_ADSIGN_ADSIGN_Pos                                  (0U)
#define    RTC_ADSIGN_ADSIGN_Msk                                  (0x1U << RTC_ADSIGN_ADSIGN_Pos)
#define    RTC_ADSIGN_ADSIGN                                      RTC_ADSIGN_ADSIGN_Msk



#define    FL_RTC_BACKUP_0                                        (0x0U)
#define    FL_RTC_BACKUP_1                                        (0x1U)
#define    FL_RTC_BACKUP_2                                        (0x2U)
#define    FL_RTC_BACKUP_3                                        (0x3U)
#define    FL_RTC_BACKUP_4                                        (0x4U)
#define    FL_RTC_BACKUP_5                                        (0x5U)
#define    FL_RTC_BACKUP_6                                        (0x6U)
#define    FL_RTC_BACKUP_7                                        (0x7U)



#define    FL_RTC_TIME_MARK_SECOND                                (0x2U << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_MINUTE                                (0x3U << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_HOUR                                  (0x4U << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_DAY                                   (0x5U << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_ALARM                                 (0x6U << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_32_SEC                                (0x7U << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_SECOND_REVERSE                        (0x9U << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_MINUTE_REVERSE                        (0xaU << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_HOUR_REVERSE                          (0xbU << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_DAY_REVERSE                           (0xcU << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_ALARM_REVERSE                         (0xdU << RTC_TMSEL_TMSEL_Pos)
#define    FL_RTC_TIME_MARK_SEC                                   (0xfU << RTC_TMSEL_TMSEL_Pos)


#define    FL_RTC_ADJUST_DIR_INCREASE                             (0x0U << RTC_ADSIGN_ADSIGN_Pos)
#define    FL_RTC_ADJUST_DIR_DECREASE                             (0x1U << RTC_ADSIGN_ADSIGN_Pos)


/**
  * @}
  */
/* Exported functions ---------------------------------------------------------------------------------*/
/** @defgroup RTC_FL_Exported_Functions RTC Exported Functions
  * @{
  */

/**
  * @brief    Enable RTC Config Time
  * @rmtoll   WER        FL_RTC_WriteEnable
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteEnable(RTC_Type *RTCx)
{
    RTCx->WER = 0xACACACAC;
}

/**
  * @brief    Disable RTC Config Time
  * @rmtoll   WER        FL_RTC_WriteDisable
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteDisable(RTC_Type *RTCx)
{
    RTCx->WER = 0x5A5A5A5A;
}

/**
  * @brief    Enable RTC Time Adjust Interrupt
  * @rmtoll   IER    ADJ_IE    FL_RTC_EnableIT_Adjust
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_Adjust(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_ADJ_IE_Msk);
}

/**
  * @brief    Get RTC Time Adjust Interrupt Enable Status
  * @rmtoll   IER    ADJ_IE    FL_RTC_IsEnabledIT_Adjust
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_Adjust(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_ADJ_IE_Msk) == RTC_IER_ADJ_IE_Msk);
}

/**
  * @brief    Disable RTC Time Adjust Interrupt
  * @rmtoll   IER    ADJ_IE    FL_RTC_DisableIT_Adjust
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_Adjust(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_ADJ_IE_Msk);
}

/**
  * @brief    Enable RTC Alarm Interrupt
  * @rmtoll   IER    ALARM_IE    FL_RTC_EnableIT_Alarm
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_Alarm(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_ALARM_IE_Msk);
}

/**
  * @brief    Get RTC Alarm Interrupt Enable Status
  * @rmtoll   IER    ALARM_IE    FL_RTC_IsEnabledIT_Alarm
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_Alarm(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_ALARM_IE_Msk) == RTC_IER_ALARM_IE_Msk);
}

/**
  * @brief    Disable RTC Alarm    Interrupt
  * @rmtoll   IER    ALARM_IE    FL_RTC_DisableIT_Alarm
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_Alarm(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_ALARM_IE_Msk);
}

/**
  * @brief    Enable RTC 1KHz Interrupt
  * @rmtoll   IER    1KHZ_IE    FL_RTC_EnableIT_1KHz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_1KHz(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_1KHZ_IE_Msk);
}

/**
  * @brief    Get RTC 1KHz Interrupt Enable Status
  * @rmtoll   IER    1KHZ_IE    FL_RTC_IsEnabledIT_1KHz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_1KHz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_1KHZ_IE_Msk) == RTC_IER_1KHZ_IE_Msk);
}

/**
  * @brief    Disable RTC 1KHz Interrupt
  * @rmtoll   IER    1KHZ_IE    FL_RTC_DisableIT_1KHz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_1KHz(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_1KHZ_IE_Msk);
}

/**
  * @brief    Enable RTC 256Hz Interrupt
  * @rmtoll   IER    256HZ_IE    FL_RTC_EnableIT_256Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_256Hz(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_256HZ_IE_Msk);
}

/**
  * @brief    Get RTC 256Hz Interrupt Enable Status
  * @rmtoll   IER    256HZ_IE    FL_RTC_IsEnabledIT_256Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_256Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_256HZ_IE_Msk) == RTC_IER_256HZ_IE_Msk);
}

/**
  * @brief    Disable RTC 256Hz Interrupt
  * @rmtoll   IER    256HZ_IE    FL_RTC_DisableIT_256Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_256Hz(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_256HZ_IE_Msk);
}

/**
  * @brief    Enable RTC 64Hz Interrupt
  * @rmtoll   IER    64HZ_IE    FL_RTC_EnableIT_64Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_64Hz(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_64HZ_IE_Msk);
}

/**
  * @brief    Get RTC 64Hz Interrupt Enable Status
  * @rmtoll   IER    64HZ_IE    FL_RTC_IsEnabledIT_64Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_64Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_64HZ_IE_Msk) == RTC_IER_64HZ_IE_Msk);
}

/**
  * @brief    Disable RTC 64Hz Interrupt
  * @rmtoll   IER    64HZ_IE    FL_RTC_DisableIT_64Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_64Hz(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_64HZ_IE_Msk);
}

/**
  * @brief    Enable RTC 16Hz Interrupt
  * @rmtoll   IER    16HZ_IE    FL_RTC_EnableIT_16Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_16Hz(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_16HZ_IE_Msk);
}

/**
  * @brief    Get RTC 16Hz Interrupt Enable Status
  * @rmtoll   IER    16HZ_IE    FL_RTC_IsEnabledIT_16Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_16Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_16HZ_IE_Msk) == RTC_IER_16HZ_IE_Msk);
}

/**
  * @brief    Disable RTC 16Hz Interrupt
  * @rmtoll   IER    16HZ_IE    FL_RTC_DisableIT_16Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_16Hz(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_16HZ_IE_Msk);
}

/**
  * @brief    Enable RTC 8Hz Interrupt
  * @rmtoll   IER    8HZ_IE    FL_RTC_EnableIT_8Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_8Hz(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_8HZ_IE_Msk);
}

/**
  * @brief    Get RTC 8Hz Interrupt Enable Status
  * @rmtoll   IER    8HZ_IE    FL_RTC_IsEnabledIT_8Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_8Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_8HZ_IE_Msk) == RTC_IER_8HZ_IE_Msk);
}

/**
  * @brief    Disable RTC 8Hz Interrupt
  * @rmtoll   IER    8HZ_IE    FL_RTC_DisableIT_8Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_8Hz(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_8HZ_IE_Msk);
}

/**
  * @brief    Enable RTC 4Hz Interrupt
  * @rmtoll   IER    4HZ_IE    FL_RTC_EnableIT_4Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_4Hz(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_4HZ_IE_Msk);
}

/**
  * @brief    Get RTC 4Hz Interrupt Enable Status
  * @rmtoll   IER    4HZ_IE    FL_RTC_IsEnabledIT_4Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_4Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_4HZ_IE_Msk) == RTC_IER_4HZ_IE_Msk);
}

/**
  * @brief    Disable RTC 4Hz Interrupt
  * @rmtoll   IER    4HZ_IE    FL_RTC_DisableIT_4Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_4Hz(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_4HZ_IE_Msk);
}

/**
  * @brief    Enable RTC 2Hz Interrupt
  * @rmtoll   IER    2HZ_IE    FL_RTC_EnableIT_2Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_2Hz(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_2HZ_IE_Msk);
}

/**
  * @brief    Get RTC 2Hz Interrupt Enable Status
  * @rmtoll   IER    2HZ_IE    FL_RTC_IsEnabledIT_2Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_2Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_2HZ_IE_Msk) == RTC_IER_2HZ_IE_Msk);
}

/**
  * @brief    Disable RTC 2Hz Interrupt
  * @rmtoll   IER    2HZ_IE    FL_RTC_DisableIT_2Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_2Hz(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_2HZ_IE_Msk);
}

/**
  * @brief    Enable RTC Second Interrupt
  * @rmtoll   IER    SEC_IE    FL_RTC_EnableIT_Second
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_Second(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_SEC_IE_Msk);
}

/**
  * @brief    Get RTC Second Interrupt Enable Status
  * @rmtoll   IER    SEC_IE    FL_RTC_IsEnabledIT_Second
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_Second(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_SEC_IE_Msk) == RTC_IER_SEC_IE_Msk);
}

/**
  * @brief    Disable RTC Second Interrupt
  * @rmtoll   IER    SEC_IE    FL_RTC_DisableIT_Second
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_Second(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_SEC_IE_Msk);
}

/**
  * @brief    Enable RTC Minute Interrupt
  * @rmtoll   IER    MIN_IE    FL_RTC_EnableIT_Minute
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_Minute(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_MIN_IE_Msk);
}

/**
  * @brief    Get RTC Minute Interrupt Enable Status
  * @rmtoll   IER    MIN_IE    FL_RTC_IsEnabledIT_Minute
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_Minute(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_MIN_IE_Msk) == RTC_IER_MIN_IE_Msk);
}

/**
  * @brief    Disable RTC Minute Interrupt
  * @rmtoll   IER    MIN_IE    FL_RTC_DisableIT_Minute
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_Minute(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_MIN_IE_Msk);
}

/**
  * @brief    Enable RTC Hour Interrupt
  * @rmtoll   IER    HOUR_IE    FL_RTC_EnableIT_Hour
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_Hour(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_HOUR_IE_Msk);
}

/**
  * @brief    Get RTC Hour Interrupt Enable Status
  * @rmtoll   IER    HOUR_IE    FL_RTC_IsEnabledIT_Hour
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_Hour(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_HOUR_IE_Msk) == RTC_IER_HOUR_IE_Msk);
}

/**
  * @brief    Disable RTC Hour  Interrupt
  * @rmtoll   IER    HOUR_IE    FL_RTC_DisableIT_Hour
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_Hour(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_HOUR_IE_Msk);
}

/**
  * @brief    Enable RTC Day Interrupt
  * @rmtoll   IER    DAY_IE    FL_RTC_EnableIT_Day
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_EnableIT_Day(RTC_Type *RTCx)
{
    SET_BIT(RTCx->IER, RTC_IER_DAY_IE_Msk);
}

/**
  * @brief    Get RTC Day Interrupt Enable Status
  * @rmtoll   IER    DAY_IE    FL_RTC_IsEnabledIT_Day
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsEnabledIT_Day(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->IER, RTC_IER_DAY_IE_Msk) == RTC_IER_DAY_IE_Msk);
}

/**
  * @brief    Disable RTC Day Interrupt
  * @rmtoll   IER    DAY_IE    FL_RTC_DisableIT_Day
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_DisableIT_Day(RTC_Type *RTCx)
{
    CLEAR_BIT(RTCx->IER, RTC_IER_DAY_IE_Msk);
}

/**
  * @brief    Clear RTC Time Adjust Interrupt Flag
  * @rmtoll   ISR    ADJ_IF    FL_RTC_ClearFlag_Adjust
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_Adjust(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_ADJ_IF_Msk);
}

/**
  * @brief    Get RTC Time Adjust Interrupt Flag
  * @rmtoll   ISR    ADJ_IF    FL_RTC_IsActiveFlag_Adjust
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_Adjust(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_ADJ_IF_Msk) == (RTC_ISR_ADJ_IF_Msk));
}

/**
  * @brief    Clear RTC Alarm Interrupt Flag
  * @rmtoll   ISR    ALARM_IF    FL_RTC_ClearFlag_Alarm
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_Alarm(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_ALARM_IF_Msk);
}

/**
  * @brief    Get RTC Alarm Interrupt Flag
  * @rmtoll   ISR    ALARM_IF    FL_RTC_IsActiveFlag_Alarm
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_Alarm(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_ALARM_IF_Msk) == (RTC_ISR_ALARM_IF_Msk));
}

/**
  * @brief    Clear RTC 1KHz Interrupt Flag
  * @rmtoll   ISR    1KHZ_IF    FL_RTC_ClearFlag_1KHz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_1KHz(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_1KHZ_IF_Msk);
}

/**
  * @brief    Get RTC 1KHz Interrupt Flag
  * @rmtoll   ISR    1KHZ_IF    FL_RTC_IsActiveFlag_1KHz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_1KHz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_1KHZ_IF_Msk) == (RTC_ISR_1KHZ_IF_Msk));
}

/**
  * @brief    Clear RTC 256Hz Interrupt Flag
  * @rmtoll   ISR    256HZ_IF    FL_RTC_ClearFlag_256Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_256Hz(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_256HZ_IF_Msk);
}

/**
  * @brief    Get RTC 256Hz Interrupt Flag
  * @rmtoll   ISR    256HZ_IF    FL_RTC_IsActiveFlag_256Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_256Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_256HZ_IF_Msk) == (RTC_ISR_256HZ_IF_Msk));
}

/**
  * @brief    Clear RTC 64Hz Interrupt Flag
  * @rmtoll   ISR    64HZ_IF    FL_RTC_ClearFlag_64Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_64Hz(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_64HZ_IF_Msk);
}

/**
  * @brief    Get RTC 64Hz Interrupt Flag
  * @rmtoll   ISR    64HZ_IF    FL_RTC_IsActiveFlag_64Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_64Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_64HZ_IF_Msk) == (RTC_ISR_64HZ_IF_Msk));
}

/**
  * @brief    Clear RTC 16Hz Interrupt Flag
  * @rmtoll   ISR    16HZ_IF    FL_RTC_ClearFlag_16Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_16Hz(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_16HZ_IF_Msk);
}

/**
  * @brief    Get RTC 16Hz Interrupt Flag
  * @rmtoll   ISR    16HZ_IF    FL_RTC_IsActiveFlag_16Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_16Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_16HZ_IF_Msk) == (RTC_ISR_16HZ_IF_Msk));
}

/**
  * @brief    Clear RTC 8Hz Interrupt Flag
  * @rmtoll   ISR    8HZ_IF    FL_RTC_ClearFlag_8Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_8Hz(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_8HZ_IF_Msk);
}

/**
  * @brief    Get RTC 8Hz Interrupt Flag
  * @rmtoll   ISR    8HZ_IF    FL_RTC_IsActiveFlag_8Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_8Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_8HZ_IF_Msk) == (RTC_ISR_8HZ_IF_Msk));
}

/**
  * @brief    Clear RTC 4Hz Interrupt Flag
  * @rmtoll   ISR    4HZ_IF    FL_RTC_ClearFlag_4Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_4Hz(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_4HZ_IF_Msk);
}

/**
  * @brief    Get RTC 4Hz Interrupt Flag
  * @rmtoll   ISR    4HZ_IF    FL_RTC_IsActiveFlag_4Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_4Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_4HZ_IF_Msk) == (RTC_ISR_4HZ_IF_Msk));
}

/**
  * @brief    Clear RTC 2Hz Interrupt Flag
  * @rmtoll   ISR    2HZ_IF    FL_RTC_ClearFlag_2Hz
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_2Hz(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_2HZ_IF_Msk);
}

/**
  * @brief    Get RTC 2Hz Interrupt Flag
  * @rmtoll   ISR    2HZ_IF    FL_RTC_IsActiveFlag_2Hz
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_2Hz(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_2HZ_IF_Msk) == (RTC_ISR_2HZ_IF_Msk));
}

/**
  * @brief    Clear RTC Second Interrupt Flag
  * @rmtoll   ISR    SEC_IF    FL_RTC_ClearFlag_Second
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_Second(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_SEC_IF_Msk);
}

/**
  * @brief    Get RTC Second Interrupt Flag
  * @rmtoll   ISR    SEC_IF    FL_RTC_IsActiveFlag_Second
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_Second(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_SEC_IF_Msk) == (RTC_ISR_SEC_IF_Msk));
}

/**
  * @brief    Clear RTC Minute Interrupt Flag
  * @rmtoll   ISR    MIN_IF    FL_RTC_ClearFlag_Minute
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_Minute(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_MIN_IF_Msk);
}

/**
  * @brief    Get RTC Minute Interrupt Flag
  * @rmtoll   ISR    MIN_IF    FL_RTC_IsActiveFlag_Minute
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_Minute(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_MIN_IF_Msk) == (RTC_ISR_MIN_IF_Msk));
}

/**
  * @brief    Clear RTC Hour Interrupt Flag
  * @rmtoll   ISR    HOUR_IF    FL_RTC_ClearFlag_Hour
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_Hour(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_HOUR_IF_Msk);
}

/**
  * @brief    Get RTC Hour Interrupt Flag
  * @rmtoll   ISR    HOUR_IF    FL_RTC_IsActiveFlag_Hour
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_Hour(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_HOUR_IF_Msk) == (RTC_ISR_HOUR_IF_Msk));
}

/**
  * @brief    Clear RTC Day Interrupt Flag
  * @rmtoll   ISR    DAY_IF    FL_RTC_ClearFlag_Day
  * @param    RTCx RTC instance
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_ClearFlag_Day(RTC_Type *RTCx)
{
    WRITE_REG(RTCx->ISR, RTC_ISR_DAY_IF_Msk);
}

/**
  * @brief    Get RTC Day Interrupt Flag
  * @rmtoll   ISR    DAY_IF    FL_RTC_IsActiveFlag_Day
  * @param    RTCx RTC instance
  * @retval   State of bit (1 or 0).
  */
__STATIC_INLINE uint32_t FL_RTC_IsActiveFlag_Day(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ISR, RTC_ISR_DAY_IF_Msk) == (RTC_ISR_DAY_IF_Msk));
}

/**
  * @brief    Get RTC Second Value
  * @rmtoll   BCDSEC        FL_RTC_ReadSecond
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadSecond(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->BCDSEC, (0x7fU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Second Value
  * @rmtoll   BCDSEC        FL_RTC_WriteSecond
  * @param    RTCx RTC instance
  * @param    second
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteSecond(RTC_Type *RTCx, uint32_t second)
{
    MODIFY_REG(RTCx->BCDSEC, (0x7fU << 0U), (second << 0U));
}

/**
  * @brief    Get RTC Minute Value
  * @rmtoll   BCDMIN        FL_RTC_ReadMinute
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadMinute(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->BCDMIN, (0x7fU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Minute Value
  * @rmtoll   BCDMIN        FL_RTC_WriteMinute
  * @param    RTCx RTC instance
  * @param    minute
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteMinute(RTC_Type *RTCx, uint32_t minute)
{
    MODIFY_REG(RTCx->BCDMIN, (0x7fU << 0U), (minute << 0U));
}

/**
  * @brief    Get RTC Hour Value
  * @rmtoll   BCDHOUR        FL_RTC_ReadHour
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadHour(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->BCDHOUR, (0x3fU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Hour Value
  * @rmtoll   BCDHOUR        FL_RTC_WriteHour
  * @param    RTCx RTC instance
  * @param    hour
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteHour(RTC_Type *RTCx, uint32_t hour)
{
    MODIFY_REG(RTCx->BCDHOUR, (0x3fU << 0U), (hour << 0U));
}

/**
  * @brief    Get RTC Day Value
  * @rmtoll   BCDDAY        FL_RTC_ReadDay
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadDay(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->BCDDAY, (0x3fU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Day Value
  * @rmtoll   BCDDAY        FL_RTC_WriteDay
  * @param    RTCx RTC instance
  * @param    day
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteDay(RTC_Type *RTCx, uint32_t day)
{
    MODIFY_REG(RTCx->BCDDAY, (0x3fU << 0U), (day << 0U));
}

/**
  * @brief    Get RTC Week Value
  * @rmtoll   BCDWEEK        FL_RTC_ReadWeek
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadWeek(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->BCDWEEK, (0x7U << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Week Value
  * @rmtoll   BCDWEEK        FL_RTC_WriteWeek
  * @param    RTCx RTC instance
  * @param    week
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteWeek(RTC_Type *RTCx, uint32_t week)
{
    MODIFY_REG(RTCx->BCDWEEK, (0x7U << 0U), (week << 0U));
}

/**
  * @brief    Get RTC Month Value
  * @rmtoll   BCDMONTH        FL_RTC_ReadMonth
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadMonth(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->BCDMONTH, (0x1fU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Month Value
  * @rmtoll   BCDMONTH        FL_RTC_WriteMonth
  * @param    RTCx RTC instance
  * @param    month
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteMonth(RTC_Type *RTCx, uint32_t month)
{
    MODIFY_REG(RTCx->BCDMONTH, (0x1fU << 0U), (month << 0U));
}

/**
  * @brief    Get RTC Year Value
  * @rmtoll   BCDYEAR        FL_RTC_ReadYear
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadYear(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->BCDYEAR, (0xffU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Year Value
  * @rmtoll   BCDYEAR        FL_RTC_WriteYear
  * @param    RTCx RTC instance
  * @param    year
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteYear(RTC_Type *RTCx, uint32_t year)
{
    MODIFY_REG(RTCx->BCDYEAR, (0xffU << 0U), (year << 0U));
}

/**
  * @brief    Get RTC Alarm Hour Value
  * @rmtoll   ALARM        FL_RTC_ReadHourAlarm
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadHourAlarm(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ALARM, (0x3fU << 16U)) >> 16U);
}

/**
  * @brief    Set RTC Alarm Hour Value
  * @rmtoll   ALARM        FL_RTC_WriteHourAlarm
  * @param    RTCx RTC instance
  * @param    hour
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteHourAlarm(RTC_Type *RTCx, uint32_t hour)
{
    MODIFY_REG(RTCx->ALARM, (0x3fU << 16U), (hour << 16U));
}

/**
  * @brief    Get RTC Alarm Minute Value
  * @rmtoll   ALARM        FL_RTC_ReadMinuteAlarm
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadMinuteAlarm(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ALARM, (0x7fU << 8U)) >> 8U);
}

/**
  * @brief    Set RTC Alarm Minute Value
  * @rmtoll   ALARM        FL_RTC_WriteMinuteAlarm
  * @param    RTCx RTC instance
  * @param    minute
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteMinuteAlarm(RTC_Type *RTCx, uint32_t minute)
{
    MODIFY_REG(RTCx->ALARM, (0x7fU << 8U), (minute << 8U));
}

/**
  * @brief    Get RTC Alarm Second Value
  * @rmtoll   ALARM        FL_RTC_ReadSecondAlarm
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadSecondAlarm(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ALARM, (0x7fU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Alarm Second Value
  * @rmtoll   ALARM        FL_RTC_WriteSecondAlarm
  * @param    RTCx RTC instance
  * @param    second
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteSecondAlarm(RTC_Type *RTCx, uint32_t second)
{
    MODIFY_REG(RTCx->ALARM, (0x7fU << 0U), (second << 0U));
}

/**
  * @brief    Set RTC Output Time Mark Signal
  * @rmtoll   TMSEL    TMSEL    FL_RTC_SetTimeMarkOutput
  * @param    RTCx RTC instance
  * @param    markSelect This parameter can be one of the following values:
  *           @arg @ref FL_RTC_TIME_MARK_SECOND
  *           @arg @ref FL_RTC_TIME_MARK_MINUTE
  *           @arg @ref FL_RTC_TIME_MARK_HOUR
  *           @arg @ref FL_RTC_TIME_MARK_DAY
  *           @arg @ref FL_RTC_TIME_MARK_ALARM
  *           @arg @ref FL_RTC_TIME_MARK_32_SEC
  *           @arg @ref FL_RTC_TIME_MARK_SECOND_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_MINUTE_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_HOUR_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_DAY_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_ALARM_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_SEC
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_SetTimeMarkOutput(RTC_Type *RTCx, uint32_t markSelect)
{
    MODIFY_REG(RTCx->TMSEL, RTC_TMSEL_TMSEL_Msk, markSelect);
}

/**
  * @brief    Get RTC Output Time Mark Signal Setting
  * @rmtoll   TMSEL    TMSEL    FL_RTC_GetTimeMarkOutput
  * @param    RTCx RTC instance
  * @retval   Returned value can be one of the following values:
  *           @arg @ref FL_RTC_TIME_MARK_SECOND
  *           @arg @ref FL_RTC_TIME_MARK_MINUTE
  *           @arg @ref FL_RTC_TIME_MARK_HOUR
  *           @arg @ref FL_RTC_TIME_MARK_DAY
  *           @arg @ref FL_RTC_TIME_MARK_ALARM
  *           @arg @ref FL_RTC_TIME_MARK_32_SEC
  *           @arg @ref FL_RTC_TIME_MARK_SECOND_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_MINUTE_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_HOUR_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_DAY_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_ALARM_REVERSE
  *           @arg @ref FL_RTC_TIME_MARK_SEC
  */
__STATIC_INLINE uint32_t FL_RTC_GetTimeMarkOutput(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->TMSEL, RTC_TMSEL_TMSEL_Msk));
}

/**
  * @brief    Get RTC Adjust Value
  * @rmtoll   ADJUST        FL_RTC_ReadAdjustValue
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadAdjustValue(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ADJUST, (0x1ffU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC Adjust Value
  * @rmtoll   ADJUST        FL_RTC_WriteAdjustValue
  * @param    RTCx RTC instance
  * @param    adjustValue
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteAdjustValue(RTC_Type *RTCx, uint32_t adjustValue)
{
    MODIFY_REG(RTCx->ADJUST, (0x1ffU << 0U), (adjustValue << 0U));
}

/**
  * @brief    Set RTC Adjust Direction
  * @rmtoll   ADSIGN    ADSIGN    FL_RTC_SetAdjustDirection
  * @param    RTCx RTC instance
  * @param    adjustDir This parameter can be one of the following values:
  *           @arg @ref FL_RTC_ADJUST_DIR_INCREASE
  *           @arg @ref FL_RTC_ADJUST_DIR_DECREASE
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_SetAdjustDirection(RTC_Type *RTCx, uint32_t adjustDir)
{
    MODIFY_REG(RTCx->ADSIGN, RTC_ADSIGN_ADSIGN_Msk, adjustDir);
}

/**
  * @brief    Get RTC Adjust Direction
  * @rmtoll   ADSIGN    ADSIGN    FL_RTC_GetAdjustDirection
  * @param    RTCx RTC instance
  * @retval   Returned value can be one of the following values:
  *           @arg @ref FL_RTC_ADJUST_DIR_INCREASE
  *           @arg @ref FL_RTC_ADJUST_DIR_DECREASE
  */
__STATIC_INLINE uint32_t FL_RTC_GetAdjustDirection(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->ADSIGN, RTC_ADSIGN_ADSIGN_Msk));
}

/**
  * @brief    Get RTC MilliSecond Counter Value
  * @rmtoll   SBSCNT        FL_RTC_ReadMilliSecondCounter
  * @param    RTCx RTC instance
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadMilliSecondCounter(RTC_Type *RTCx)
{
    return (uint32_t)(READ_BIT(RTCx->SBSCNT, (0xffU << 0U)) >> 0U);
}

/**
  * @brief    Set RTC MilliSecond Counter Value
  * @rmtoll   SBSCNT        FL_RTC_WriteMilliSecondCounter
  * @param    RTCx RTC instance
  * @param    milliSecondCount
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteMilliSecondCounter(RTC_Type *RTCx, uint32_t milliSecondCount)
{
    MODIFY_REG(RTCx->SBSCNT, (0xffU << 0U), (milliSecondCount << 0U));
}

/**
  * @brief    Get RTC Backup Register
  * @rmtoll   BACKUP        FL_RTC_ReadBackupRegisters
  * @param    RTCx RTC instance
  * @param    backupRegNum This parameter can be one of the following values:
  *           @arg @ref FL_RTC_BACKUP_0
  *           @arg @ref FL_RTC_BACKUP_1
  *           @arg @ref FL_RTC_BACKUP_2
  *           @arg @ref FL_RTC_BACKUP_3
  *           @arg @ref FL_RTC_BACKUP_4
  *           @arg @ref FL_RTC_BACKUP_5
  *           @arg @ref FL_RTC_BACKUP_6
  *           @arg @ref FL_RTC_BACKUP_7
  * @retval
  */
__STATIC_INLINE uint32_t FL_RTC_ReadBackupRegisters(RTC_Type *RTCx, uint32_t backupRegNum)
{
    FL_RTC_Backup_ADDR  *addr = (FL_RTC_Backup_ADDR *)&RTCx->BKR0;
    return (uint32_t)(READ_BIT(addr->backup[backupRegNum], 0xFFFFFFFFu));
}

/**
  * @brief    Set RTC Backup Register
  * @rmtoll   BACKUP        FL_RTC_WriteBackupRegisters
  * @param    RTCx RTC instance
  * @param    backupReg
  * @param    backupNum
  * @retval   None
  */
__STATIC_INLINE void FL_RTC_WriteBackupRegisters(RTC_Type *RTCx, uint32_t backupReg, uint32_t backupNum)
{
    FL_RTC_Backup_ADDR  *addr = (FL_RTC_Backup_ADDR *)&RTCx->BKR0;
    MODIFY_REG(addr->backup[backupNum], (0xFFFFFFFFu), backupReg);
}

/**
  * @}
  */

/** @defgroup RTC_FL_EF_Init Initialization and de-initialization functions
  * @{
  */
FL_ErrorStatus FL_RTC_DeInit(RTC_Type *RTCx);
void FL_RTC_StructInit(FL_RTC_InitTypeDef *initStruct);
FL_ErrorStatus FL_RTC_GetTime(RTC_Type *RTCx, FL_RTC_InitTypeDef *initStruct);
FL_ErrorStatus FL_RTC_Init(RTC_Type *RTCx, FL_RTC_InitTypeDef *initStruct);
FL_ErrorStatus FL_RTC_ConfigTime(RTC_Type *RTCx, FL_RTC_InitTypeDef *initStruct);

/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */

#ifdef __cplusplus
}
#endif

#endif /* __FM33LE0XXA_FL_RTC_H*/

/*************************Py_Code_Generator Version: 0.1-0.11-0.1 @ 2020-09-22*************************/
/********************** (C) COPYRIGHT Fudan Microelectronics **** END OF FILE ***********************/
